package com.screx.mcloud.lib.utils

import android.annotation.SuppressLint
import android.app.Activity
import android.content.ClipboardManager
import android.content.Context
import android.content.pm.PackageManager
import android.graphics.Bitmap
import android.media.MediaMetadataRetriever
import android.net.ConnectivityManager
import android.net.Uri
import android.provider.ContactsContract
import android.provider.Settings
import android.telephony.PhoneNumberUtils
import android.text.InputFilter
import android.text.TextUtils
import android.util.DisplayMetrics
import android.view.View
import android.view.inputmethod.InputMethodManager
import java.io.BufferedOutputStream
import java.io.File
import java.io.FileOutputStream
import java.io.IOException
import java.text.ParseException
import java.text.SimpleDateFormat
import java.util.*
import java.util.regex.Pattern


/**
 * 基础工具类
 */
open class BaseUtils {

    /**
     * 获取屏幕信息
     */
    fun screenInfo(activity: Activity): DisplayMetrics {
        val displayMetrics = DisplayMetrics()
        activity.windowManager?.defaultDisplay?.getMetrics(displayMetrics)
        return displayMetrics
    }

    /**
     * 根据手机的分辨率从 px(像素) 的单位 转成为 dp
     */
    fun px2dip(context: Context, pxValue: Float): Int {
        val scale = context.resources.displayMetrics.density
        return (pxValue / scale + 0.5f).toInt()
    }

    /**
     * 根据手机的分辨率从 dp 的单位 转成为 px(像素)
     */
    fun dip2px(context: Context, dpValue: Float): Int {
        val scale = context.resources.displayMetrics.density
        return (dpValue * scale + 0.5f).toInt()
    }

    /**
     * 禁止EditText输入特殊字符
     */
    var specialSymbolFilter = InputFilter { charSequence, _, _, _, _, _ ->
        val speChat = "[`~!@#$%^&*()\\-+_=|{}':;,\\[\\].<>/?！￥…（）—【】‘；：”“’。，、？]"
        val pattern = Pattern.compile(speChat)
        val matcher = pattern.matcher(charSequence.toString())
        return@InputFilter if (matcher.find())
            ""
        else
            null
    }

    /**
     * 判断是否为WI-FI环境
     */
    fun isWifi(mContext: Context): Boolean {
        val connectivityManager = mContext
            .getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
        val activeNetInfo = connectivityManager.activeNetworkInfo
        return (activeNetInfo?.type == ConnectivityManager.TYPE_WIFI)
    }

    /**
     * 禁止输空格
     */
    var spaceFilter = InputFilter { source, _, _, _, _, _ ->
        return@InputFilter if (source == " ")
            ""
        else
            null
    }

    /**
     * 禁止输回车
     */
    var enterFilter = InputFilter { source, _, _, _, _, _ ->
        return@InputFilter if (source == "\n")
            ""
        else
            null
    }

    /**
     * 验证邮箱
     *
     * @param email 邮箱
     * @return 返回
     */
    fun isEmail(email: String): Boolean {
        return Pattern.matches(
            "^([a-z0-9A-Z]+[-|.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$",
            email
        )
    }

    /**
     * 是否为数字
     */
    fun isNum(number: String): Boolean {
        return Pattern.matches("[0-9]*", number)
    }
    /**
     * 是否为合法的密码
     */
    fun isPsd(number: String): Boolean {
        return Pattern.matches("(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])[a-zA-Z0-9]{6,20}", number)
    }

    /**
     * 隐藏软键盘
     */
    fun hidKeyBoard(view: View) {
        val imm =
            view.context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager //得到InputMethodManager的实例
        if (imm.isActive) {
            imm.hideSoftInputFromWindow(view.applicationWindowToken, 0)
        }
    }

    /**
     * 根据时间戳转日期
     */
    @SuppressLint("SimpleDateFormat")
    fun dateToString(date: Date): String {
        val format = SimpleDateFormat("yyyy-MM-dd")
        return format.format(date)
    }

    /**
     * 时间戳转字符串
     *
     * @param milSecond 时间戳
     * @param pattern   格式
     * @return 日期
     */
    @SuppressLint("SimpleDateFormat")
    fun longToString(milSecond: Long, pattern: String): String {
        val date = Date(milSecond)
        val format = SimpleDateFormat(pattern)
        return format.format(date)
    }
    /**
     * 将时间戳转换为时间
     */
     fun stampToDate(s: Long): String? {
        val res: String
        val simpleDateFormat = SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
        val lt: Long = s
        val date = Date(lt)
        res = simpleDateFormat.format(date)
        return res
    }

    /**
     * 时间差
     */
    open fun getDatePoor(endDate: Date, nowDate: Date): String? {
        val nd = 1000 * 24 * 60 * 60.toLong()
        val nh = 1000 * 60 * 60.toLong()
        val nm = 1000 * 60.toLong()
        // long ns = 1000;
        // 获得两个时间的毫秒时间差异
        val diff = endDate.time - nowDate.time
        // 计算差多少天
        val day = diff / nd
        // 计算差多少小时
        val hour = diff % nd / nh
        // 计算差多少分钟
        val min = diff % nd % nh / nm
        // 计算差多少秒//输出结果
        // long sec = diff % nd % nh % nm / ns;
        return hour.toString() + "小时" + min + "分钟"
    }
    /**
     * 字符串转为时间戳
     *
     * @param dateString 日期
     * @param pattern    格式
     * @return 时间戳
     */
    @SuppressLint("SimpleDateFormat")
    fun stringToLong(dateString: String, pattern: String): Long {
        val dateFormat = SimpleDateFormat(pattern)
        var date: Date? = null
        try {
            date = dateFormat.parse(dateString)
        } catch (e: ParseException) {
            e.printStackTrace()
        }
        return date?.time!!
    }

    /**
     * Bitmap转File
     */
    fun bitmapToFile(bitmap: Bitmap, filePath: String): File {
        val file = File(filePath) //将要保存图片的路径
        try {
            val bos = BufferedOutputStream(FileOutputStream(file))
            bitmap.compress(Bitmap.CompressFormat.JPEG, 100, bos)
            bos.flush()
            bos.close()
        } catch (e: IOException) {
            e.printStackTrace()
        }
        return file
    }

    /**
     * 将图片转换成Base64编码的字符串
     */
//    fun getImgStr(imgFile: String): String {
//        //将图片文件转化为字节数组字符串，并对其进行Base64编码处理
//        val inputStream: InputStream?
//        var data: ByteArray? = null
//        //读取图片字节数组
//        try {
//            inputStream = FileInputStream(imgFile)
//            data = ByteArray(inputStream.available())
//            inputStream.read(data)
//            inputStream.close()
//        } catch (e: IOException) {
//            e.printStackTrace()
//        }
//        return Base64Util.encode(data)
//    }


    /**
     *
     * 获取通讯录中的所有联系人存储在Map中
     * 注：Map中号码唯一作为key，号码对应的联系人作为value
     * 对同一个号码存储多个联系人姓名的做了处理，这里只存一个姓名。即一个号码只对应一个姓名
     * @param context
     * @return
     */
    fun getAllContacts(context: Context): Map<String, String> {
        val contactsMap: MutableMap<String, String> =
            HashMap()
        //生成ContentResolver对象
        val contentResolver = context.contentResolver
        // 获得所有的联系人
        /*Cursor cursor = contentResolver.query(
                ContactsContract.Contacts.CONTENT_URI, null, null, null, null);
         */
        //这段代码和上面代码是等价的，使用两种方式获得联系人的Uri
        val cursor = contentResolver.query(
            Uri.parse("content://com.android.contacts/contacts"),
            null,
            null,
            null,
            null
        )
        // 循环遍历
        if (cursor!!.moveToFirst()) {
            val idColumn =
                cursor.getColumnIndex(ContactsContract.Contacts._ID)
            val displayNameColumn =
                cursor.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME)
            do {
                // 获得联系人的ID
                val contactId = cursor.getString(idColumn)
                // 获得联系人姓名
                val displayName = cursor.getString(displayNameColumn)
                //显示获得的联系人信息
                println("联系人姓名：$displayName")
                // 查看联系人有多少个号码，如果没有号码，返回0
                val phoneCount = cursor.getInt(
                    cursor
                        .getColumnIndex(ContactsContract.Contacts.HAS_PHONE_NUMBER)
                )
                if (phoneCount > 0) {
                    // 获得联系人的电话号码列表
                    val phoneCursor = context.contentResolver.query(
                        ContactsContract.CommonDataKinds.Phone.CONTENT_URI, null,
                        ContactsContract.CommonDataKinds.Phone.CONTACT_ID
                                + "=" + contactId, null, null
                    )
                    phoneCursor?.let {
                        if (it.moveToFirst()) {
                            do {
                                //遍历所有的联系人下面所有的电话号码
                                val phoneNumber =
                                    phoneCursor.getString(
                                        phoneCursor.getColumnIndex(
                                            ContactsContract.CommonDataKinds.Phone.NUMBER
                                        )
                                    )
                                //显示获得的号码
                                println("联系人电话：$phoneNumber")
                                if (!contactsMap.containsKey(phoneNumber)) {
                                    contactsMap[handlePhoneNum(phoneNumber)] = displayName
                                }
                            } while (phoneCursor.moveToNext())
                        }
                    }
                }
            } while (cursor.moveToNext())
        }
        return contactsMap
    }

    /**
     *
     * 处理号码的方法
     * 规则：
     * 1、去除号码中所有的非数字
     * 2、如果号码为13位（即手机号）就去掉86
     * @param phoneNum
     * @return
     */
    private fun handlePhoneNum(phoneNum: String): String {
        var phoneNum = phoneNum
        if (!TextUtils.isEmpty(phoneNum)) {
            phoneNum = phoneNum.replace("\\D".toRegex(), "")
        }
        return if (phoneNum.length == 13 && phoneNum.startsWith("86")) {
            phoneNum.substring(2)
        } else phoneNum
    }

    /**
     * 获取版本Code
     */
    fun getVersionName(context: Context): String {
        var localVersion = ""
        try {
            val packageInfo = context.applicationContext.packageManager
                .getPackageInfo(context.packageName, 0)
            localVersion = packageInfo.versionName
        } catch (e: PackageManager.NameNotFoundException) {
            e.printStackTrace();
        }
        return localVersion
    }

    /**
     * 获取当前手机系统版本号
     *
     * @return  系统版本号
     */
    fun getSystemVersion(): String {
        return android.os.Build.VERSION.RELEASE
    }

    /**
     * 获取手机厂商
     *
     * @return  手机厂商
     */
    fun getDeviceBrand(): String {
        return android.os.Build.BRAND
    }
//    fun getTransform(num: Int?): String {
//        val kilo = 1000
//        val standard = 10000
//        val hotNum: Double?
//        if (num < 1000) {
//            return num!!.toString()
//        } else if (num < standard) {
//            val initial = num!!.toDouble() / 1000
//            val decimal = BigDecimal(initial)
//            hotNum = decimal.setScale(1, BigDecimal.ROUND_HALF_UP).toDouble()
//            return hotNum.toString() + "k"
//        } else {
//            val initial = num!!.toDouble() / 10000
//            val decimal = BigDecimal(initial)
//            hotNum = decimal.setScale(1, BigDecimal.ROUND_HALF_UP).toDouble()
//            return hotNum.toString() + "w"
//        }
//    }

    /**
     * 获取剪贴板的文本，仅获取Item中类型是String的文本
     *
     * @return 剪贴板的文本
     */
    fun getTextFromText(mContext: Context): String? {
        val clipboard =
            mContext.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
        val clip = clipboard.primaryClip
        return if (clip != null && clip!!.itemCount > 0 && clip!!.getItemAt(0).text.isNotEmpty()
        ) {
            clip!!.getItemAt(0).text.toString()
        } else null
    }

    /**
     * 判断手机号是否符合规范
     * @param phoneNo 输入的手机号
     * @return
     */
    open fun isPhoneNumber(phoneNo: String): Boolean {
        if (TextUtils.isEmpty(phoneNo)) {
            return false
        }
        if (phoneNo.length == 11) {
            for (i in 0..10) {
                if (!PhoneNumberUtils.isISODigit(phoneNo[i])) {
                    return false
                }
            }
            val p = Pattern.compile(
                "^((13[^4,\\D])" + "|(134[^9,\\D])" +
                        "|(14[0-9])" +
                        "|(15[0-9])" +
                        "|(17[3,6-8])" +
                        "|(19[0-9])" +
                        "|(16[0-9])" +
                        "|(18[0-9]))\\d{8}$"
            )
            val m = p.matcher(phoneNo)
            return m.matches()
        }
        return false
    }

    /**
     * 获取设备id
     */
    open fun getAndroidId(context: Context): String? {
        return Settings.System.getString(context.contentResolver, Settings.System.ANDROID_ID)
    }


}